home *** CD-ROM | disk | FTP | other *** search
/ FishMarket 1.0 / FishMarket v1.0.iso / fishies / 326-350 / disk_331 / csh / src / comm1.c next >
C/C++ Source or Header  |  1992-05-06  |  16KB  |  790 lines
  1. /*
  2.  * COMM1.C
  3.  *
  4.  * Matthew Dillon, August 1986
  5.  *
  6.  * Version 2.07M by Steve Drew 10-Sep-87
  7.  *
  8.  * Version 4.01A by Carlo Borreo & Cesare Dieni 17-Feb-90
  9.  *
  10.  */
  11.  
  12. #define DIR_SHORT 0x01
  13. #define DIR_FILES 0x02
  14. #define DIR_DIRS  0x04
  15. #define DIR_NOCOL 0x08
  16. #define DIR_NAMES 0x10
  17.  
  18. extern int has_wild;
  19.  
  20. /*
  21.     Parse the options specified in sw[]
  22.     Setting a bit in global variable options
  23.     for each one found
  24. */
  25.  
  26. get_opt(sw,count)
  27. char *sw;
  28. int *count;
  29. {
  30. register char *c,*s;
  31. unsigned int l,i = 0;
  32.  
  33. options=0;
  34. while((++i < ac) && (av[i][0] == '-')) {
  35.     for (c = av[i]+1; *c ; c++) {
  36.         for(l = 0,s = sw;*s && *s != *c; ++s) ++l;
  37.         if (*s) options |= (1 << l);
  38.         }
  39.     }
  40. *count = i;
  41. }
  42.  
  43. do_sleep()
  44. {
  45. register int i;
  46.  
  47. if (ac == 2) for (i=atoi(av[1]); i>0 && !CHECKBREAK(); i-=2) Delay(100L);
  48. return 0;
  49. }
  50.  
  51. do_protect()
  52. {
  53. register long mask=0xf;
  54. register char *s, *p;
  55. static char flags[]="DEWRAPSH";
  56. register unsigned short i;
  57.  
  58. for (s=av[--ac]; *s; s++)
  59.     if (p=index(flags, toupper(*s))) mask^=(1 << (p-flags));
  60.     else ierror(av[ac],500);
  61. for (i=1; i<ac; i++) if (!SetProtection(av[i],mask)) pError(av[i]);
  62. return 0;
  63. }
  64.  
  65. do_filenote()
  66. {
  67. char *note=av[--ac];
  68. register unsigned int i;
  69.  
  70. for (i=1; i<ac; i++) if (!SetComment(av[i], note)) pError(av[i]);
  71. return 0;
  72. }
  73.  
  74. do_cat()
  75. {
  76. FILE *fopen(), *fi;
  77. register unsigned int lctr;
  78. unsigned int i;
  79. char buf[256];
  80.  
  81. get_opt("n",&i);
  82. if (i>=ac) {
  83.     if (has_wild) { printf("No files matching\n"); return 20; }
  84.     lctr=0;
  85.     while (gets(buf) && !dobreak()) {
  86.         if (options) printf("%4d ",++lctr);
  87.         puts(buf);
  88.         }
  89.     }
  90. for (; i<ac; i++)
  91.     if (fi = fopen (av[i], "r")) {
  92.         lctr=0;
  93.         while (fgets(buf,256,fi) && !dobreak()) {
  94.             if (options) printf("%4d ",++lctr);
  95.             printf("%s",buf);
  96.             }
  97.         fclose (fi);
  98.         }
  99.     else pError(av[i]);
  100. return 0;
  101. }
  102.  
  103. do_info()
  104. {
  105. BPTR lock;
  106. struct InfoData *info;
  107. long size, free;
  108. char *p, buf[130], *state;
  109. struct DirectoryEntry *de_head=NULL, *de;
  110.  
  111. info=(struct InfoData *)AllocMem((long)sizeof(struct InfoData),MEMF_PUBLIC);
  112. AddDADevs(&de_head, DLF_DEVICES | DLF_DISKONLY );
  113. Myprocess->pr_WindowPtr = (APTR)(-1);
  114. printf ("Unit  Size  Bytes  Used Blk/By-Free Full Errs  Status    Name\n");
  115. for (de=de_head; de; de=de->de_Next) {
  116.     printf("%-5s",de->de_Name);
  117.     if (lock=Lock(de->de_Name,ACCESS_READ)) {
  118.         if (Info(lock, info)) {
  119.         PathName(lock, buf, 128L);
  120.         if (p=index(buf,':')) *p = '\0';
  121.         size = ((info->id_NumBlocks + 2)* info->id_BytesPerBlock)/ 1024;
  122.         free = (((info->id_NumBlocks-info->id_NumBlocksUsed))*
  123.                info->id_BytesPerBlock)/ 1024;
  124.         switch(info->id_DiskState) {
  125.             case ID_WRITE_PROTECTED: state="Read Only "; break;
  126.             case ID_VALIDATED:     state="Read/Write"; break;
  127.             case ID_VALIDATING:     state="Validating"; break;
  128.             }
  129.         printf("%4ld%c%6ld%7ld%7ld%4ld%c%4ld%%%4ld  %s %s\n",
  130.             (size>1024) ? ((size+512) >> 10) : size,
  131.             (size>1024) ? 'M' : 'K',
  132.             info->id_BytesPerBlock,
  133.             info->id_NumBlocksUsed,
  134.             info->id_NumBlocks-info->id_NumBlocksUsed,
  135.             (free>1024) ? ((free+512) >> 10) : free,
  136.             (free>1024) ? 'M' : 'K',
  137.             (info->id_NumBlocksUsed * 100)/info->id_NumBlocks,
  138.             info->id_NumSoftErrors,
  139.             state,
  140.             buf);
  141.         }
  142.         else pError (de->de_Name);
  143.         UnLock(lock);
  144.         }
  145.     else puts("  No disk present");
  146.     }
  147. FreeDAList(&de_head);
  148. Myprocess->pr_WindowPtr = NULL;
  149. FreeMem(info,(long)sizeof(struct InfoData));
  150. return 0;
  151. }
  152.  
  153. /* things shared with display_file */
  154.  
  155. BPTR lastlock;
  156. int filecount, col;
  157. long bytes, blocks;
  158.  
  159. /*
  160.  * the args passed to do_dir will never be expanded
  161.  */
  162. do_dir()
  163. {
  164. int i, c, eac;
  165. char **eav;
  166.  
  167. col = filecount = 0;
  168. bytes = blocks = 0L;
  169. lastlock=NULL;
  170.  
  171. get_opt("sfdcn",&i);
  172.  
  173. if (ac == i) { ++ac; av[i]=""; }
  174. if (!(options & (DIR_FILES | DIR_DIRS))) options|=(DIR_FILES | DIR_DIRS);
  175.  
  176. for (; i<ac && !CHECKBREAK(); ++i)
  177.     if (eav = expand(av[i], &eac)) {
  178.         QuickSort(eav, eac);
  179.         for(c=0; c<eac && !CHECKBREAK(); ++c)
  180.             if (options & DIR_NAMES)
  181.                 puts(eav[c]);
  182.             else
  183.                 display_file(eav[c]);
  184.         free_expand (eav);
  185.         }
  186. if (col) printf("\n");
  187. if (filecount>1) {
  188.     blocks += filecount; /* account for dir blocks */
  189.     printf(" %ld Blocks, %ld Bytes used in %d files\n",
  190.         blocks, bytes, filecount);
  191.     }
  192. if (lastlock) UnLock(lastlock);
  193. return 0;
  194. }
  195.  
  196. display_file(filestr)
  197. char *filestr;
  198. {
  199. long atol();
  200. int isadir,slen;
  201. char sc, *fi, *base, buf[130];
  202. BPTR thislock;
  203.  
  204. base=BaseName(filestr);
  205. sc = *base;
  206. *base = '\0';
  207. thislock=Lock(filestr,SHARED_LOCK);
  208. /* if (thislock==NULL) return; */
  209. if (lastlock==NULL || CompareLock(thislock,lastlock)) {
  210.     if (col) printf("\n");
  211.     col = 0;
  212.     PathName(thislock, buf, 128L);
  213.     printf("Directory of %s\n", buf);
  214.     if (lastlock) UnLock(lastlock);
  215.     lastlock=thislock;
  216.     }
  217. else UnLock(thislock);
  218. *base = sc;
  219. slen = strlen(base);
  220. fi = base + slen + 1;
  221. isadir = (fi[12] =='D');
  222.  
  223. if (!(((options & DIR_FILES) && !isadir) ||
  224.     ((options & DIR_DIRS) &&  isadir)))
  225.         return;
  226. if (isadir && !(options & DIR_NOCOL)) printf ("\23333m");
  227. if (options & DIR_SHORT) {
  228.     if (col==3 && slen>18) { printf("\n"); col = 0; }
  229.     if (slen>18) { printf(" %-37s",base); col+= 2; }
  230.         else { printf(" %-18s",base); col++; }
  231.     if (col > 3) { printf("\n"); col=0; }
  232.     }
  233. else printf("   %-24s %s",base ,fi);
  234. if (isadir && !(options & DIR_NOCOL)) printf("\2330m");
  235. fi[16] = fi[21] = '\0';
  236. bytes  += atol(fi+10);
  237. blocks += atol(fi+17);
  238. filecount++;
  239. }
  240.  
  241. do_quit()
  242. {
  243. if (Src_stack) {
  244.     Quit = 1;
  245.     return(do_return());
  246.     }
  247. main_exit(0);
  248. }
  249.  
  250. do_echo()
  251. {
  252. int i;
  253.  
  254. get_opt("n",&i);
  255. for ( ; i<ac; i++) {
  256.     printf("%s", av[i]);
  257.     if (i != ac-1) printf(" ");
  258.     }
  259. if (!options) printf("\n");
  260. return 0;
  261. }
  262.  
  263. /* gets a line from file, joining two lines if the first ends in '\' */
  264.  
  265. char *myfgets(buf, buflen, file)
  266. char *buf;
  267. FILE *file;
  268. {
  269. char *bufptr=buf, *limit=buf+buflen;
  270.  
  271. do {
  272.     if (fgets(bufptr, limit-bufptr, file)==NULL) {
  273.         if (bufptr != buf)
  274.             fprintf(stderr,"Source: file ends in '\\'\n");
  275.         return NULL;
  276.         }
  277.     bufptr = bufptr+strlen(bufptr)-2;
  278.     } while (*bufptr=='\\');
  279. return buf;
  280. }
  281.  
  282. do_source(str)
  283. char *str;
  284. {
  285. register FILE *fi;
  286. char buf[256];
  287. int len;
  288.  
  289. if (Src_stack == MAXSRC) {
  290.     ierror(NULL,217);
  291.     return -1;
  292.     }
  293. if ((fi = fopen (av[1], "r")) == 0) { pError(av[1]); return -1;    }
  294. set_var(LEVEL_SET, v_passed, next_word(next_word(str)));
  295. ++H_stack;
  296. Src_pos[Src_stack] = 0;
  297. Src_base[Src_stack] = (long)fi;
  298. ++Src_stack;
  299. while (myfgets (buf, 256, fi) && !dobreak()) {
  300.     len = strlen(buf);
  301.     buf[len-1] = '\0';
  302.     Src_pos[Src_stack - 1] += len;
  303.     if (Verbose && !forward_goto) fprintf(stderr,"%s\n",buf);
  304.     exec_command (buf);
  305.     }
  306. --H_stack;
  307. --Src_stack;
  308. if (forward_goto) ierror(NULL,501);
  309. forward_goto = 0;
  310. unset_level(LEVEL_LABEL + Src_stack);
  311. unset_var(LEVEL_SET, v_gotofwd);
  312. unset_var(LEVEL_SET, v_passed);
  313. fclose (fi);
  314. return 0;
  315. }
  316.  
  317. /*
  318.  * set process cwd name and $_cwd, if str != NULL also print it.
  319.  */
  320. do_pwd(str)
  321. char *str;
  322. {
  323. char pwd[130];
  324.  
  325. PathName(Myprocess->pr_CurrentDir, pwd, 128L);
  326. if (str) puts(pwd);
  327. set_var(LEVEL_SET, v_cwd, pwd);
  328. /* put the current dir name in our CLI task structure */
  329. CtoBStr(pwd, Mycli->cli_SetName, 128L);
  330. return 0;
  331. }
  332.  
  333. /*
  334.  * CD
  335.  *
  336.  * CD(str, 0)      -do CD operation.
  337.  *
  338.  */
  339.  
  340. do_cd(str)
  341. char *str;
  342. {
  343. BPTR oldlock, filelock;
  344.  
  345. str=next_word(str);
  346. if (!strcmp("..",str)) str="/";
  347. filelock=Lock(str,ACCESS_READ);
  348. if (filelock==NULL) { pError(str); return 20; }
  349. if (!isdir(str)) { UnLock(filelock); ierror(str,212); return 20; }
  350. if (oldlock=CurrentDir(filelock)) UnLock(oldlock);
  351. do_pwd(NULL);
  352. return 0;
  353. }
  354.  
  355. do_mkdir()
  356. {
  357. register unsigned int i;
  358. BPTR lock;
  359.  
  360. for (i=1; i<ac; ++i) {
  361.     if (exists(av[i])) ierror(av[i],203);
  362.     else if (lock=CreateDir(av[i])) UnLock (lock);
  363.     else pError(av[i]);
  364.     }
  365. return 0;
  366. }
  367.  
  368. do_mv()
  369. {
  370. char *dest, buf[256];
  371. int dirflag;
  372. register unsigned int i;
  373.  
  374. dirflag=isdir(dest=av[--ac]);
  375. if (ac>3 && !dirflag) { ierror(dest, 507); return (-1); }
  376. for (i=1; i<ac; ++i) {
  377.     strcpy(buf, dest);
  378.     if (dirflag) TackOn(buf, BaseName(av[i]));
  379.     if (Rename(av[i], buf)==0)
  380.         { pError(av[i]); return -1; }
  381.     }
  382. return 0;
  383. }
  384.  
  385. int dirstoo;
  386.  
  387. all_args(args, action, dirsflag)
  388. char *args;
  389. int (*action)();
  390. {
  391. unsigned int i;
  392.  
  393. get_opt(args, &i);
  394. dirstoo=dirsflag;
  395. for (; i<ac && !dobreak(); ++i)
  396.     if (isdir(av[i])) {
  397.         if (options & 1) recurse(av[i], action);
  398.             else if (dirstoo) (*action)(av[i]);
  399.         }
  400.     else (*action)(av[i]);
  401. return 0;
  402. }
  403.  
  404. char *searchstring;
  405.  
  406. search_file(s)
  407. char *s;
  408. {
  409. FILE *fopen(), *fi;
  410. register char *p;
  411. register unsigned int
  412.     nocasedep, lctr, len, excl=((options & 16) !=0 ), yesno;
  413. char buf[256], lowbuf[256], searchit[256], first;
  414.  
  415. if (strcmp("STDIN",s)) fi=fopen(s,"r"); else fi=stdin;
  416. if (fi==NULL) { pError(s); return; }
  417. nocasedep=!(options & 2);
  418. lctr=0;
  419. if (!(options & 32)) printf("Examining %s...\n",s);
  420. strcpy(searchit,searchstring);
  421. if (options & 4) strcat(searchit,"\n");
  422. len=strlen(searchit);
  423. if (nocasedep) strupr(searchit);
  424. first=*searchit;
  425. while (fgets(buf,256,fi) && !dobreak()) {
  426.     lctr++;
  427.     if (options & 4) yesno=compare_ok(searchit, buf, options & 2);
  428.     else {
  429.         if (nocasedep) {
  430.             strcpy(lowbuf,buf);
  431.             strupr(lowbuf);
  432.             p=lowbuf;
  433.             }
  434.         else p=buf;
  435.         while ((p=index(p,first)) && strncmp(p++,searchit,len)) ;
  436.         yesno= (p!=NULL);
  437.         }
  438.     if (yesno ^ excl) {
  439.             /* default: print line numbers */
  440.         if (!(options & 8)) printf("%4d ",lctr);
  441.         printf("%s",buf);
  442.         }
  443.     }
  444. if (fi!=stdin) fclose (fi);
  445. }
  446.  
  447. do_search()
  448. {
  449. searchstring=av[--ac];
  450. all_args("rcwneq", search_file, 0);
  451. return 0;
  452. }
  453.  
  454. rm_file(file)
  455. char *file;
  456. {
  457. if (has_wild) printf(" %s...",file);
  458. if (options & 2) SetProtection(file,0L);
  459. if (!DeleteFile(file)) pError (file); else if (has_wild) printf("Deleted\n");
  460. }
  461.  
  462. do_rm()
  463. {
  464. all_args("rp", rm_file, 1);
  465. return 0;
  466. }
  467.  
  468. recurse(name, action)
  469. char *name;
  470. int (*action)();
  471. {
  472. register BPTR lock, cwd;
  473. register FIB *fib=(FIB *)AllocMem((long)sizeof(FIB),MEMF_PUBLIC);
  474. char *namecopy=malloc(256);
  475.  
  476. if (name[0] =='\0') return;
  477. namecopy[0]=0;
  478. if (lock=Lock(name,ACCESS_READ)) {
  479.     cwd =CurrentDir(lock);
  480.     if (Examine(lock, fib))
  481.     while (ExNext(lock, fib) && !CHECKBREAK()) {
  482.         if (*namecopy) { (*action)(namecopy); namecopy[0]=0; }
  483.         if (fib->fib_DirEntryType>=0) recurse(fib->fib_FileName,action);
  484.         else strcpy(namecopy,fib->fib_FileName);
  485.         }
  486.     if (*namecopy) (*action)(namecopy);
  487.     UnLock(CurrentDir(cwd));
  488.     if (dirstoo) (*action)(name);
  489.     }
  490. else pError(name);
  491. free(namecopy);
  492. FreeMem(fib, (long)sizeof(FIB));
  493. }
  494.  
  495. do_history()
  496. {
  497. register struct HIST *hist;
  498. int i = H_tail_base;
  499. int len = (av[1]) ? strlen(av[1]) : 0;
  500.  
  501. for (hist = H_tail; hist && !dobreak(); hist = hist->prev)
  502.     if (len == 0 || !strncmp(av[1], hist->line, len))
  503.         printf("%3d %s\n", i++, hist->line);
  504. return 0;
  505. }
  506.  
  507. do_mem()
  508. {
  509. long cfree, ffree;
  510. extern long AvailMem();
  511.  
  512. Forbid();
  513. cfree = AvailMem (MEMF_CHIP);
  514. ffree = AvailMem (MEMF_FAST);
  515. Permit();
  516. if (ffree) printf ("FAST memory: %ld\nCHIP memory: %ld\n", ffree, cfree);
  517. printf("Total  Free: %ld\n", cfree+ffree);
  518. return 0;
  519. }
  520.  
  521. do_forline()
  522. {
  523. char vname[33], buf[256];
  524. register unsigned short lctr;
  525. FILE *f;
  526. char *cstr;
  527.  
  528. strcpy(vname,av[1]);
  529. f=fopen(av[2],"r");
  530. if (f==NULL) pError(av[2]);
  531. lctr=0;
  532. ++H_stack;
  533. cstr = compile_av (av, 3, ac, ' ', 0);
  534. while (fgets(buf,256,f) && !dobreak()) {
  535.     buf[strlen(buf)-1]='\0';    /* remove CR */
  536.     lctr++;
  537.     set_var(LEVEL_SET, vname, buf);
  538.     sprintf(buf,"%d",lctr);
  539.     set_var(LEVEL_SET, v_linenum, buf);
  540.     exec_command(cstr);
  541.     }
  542. fclose(f);
  543. --H_stack;
  544. free (cstr);
  545. unset_var (LEVEL_SET, vname);
  546. unset_var (LEVEL_SET, v_linenum);
  547. return 0;
  548. }
  549.  
  550. do_fornum()
  551. {
  552. char vname[33], buf[16];
  553. int n1, n2, step, i, verbose;
  554. char *cstr;
  555.  
  556. get_opt("vs",&i);
  557. verbose=(options & 1);
  558. strcpy(vname,av[i++]);
  559. n1=myatoi(av[i++],-32767,32767); if (atoierr) return 20;
  560. n2=myatoi(av[i++],-32767,32767); if (atoierr) return 20;
  561. if (options & 2) {
  562.     step=myatoi(av[i++],-32767,32767); if (atoierr) return 20;
  563.     }
  564. else
  565.     step=1;
  566. ++H_stack;
  567. cstr = compile_av (av, i, ac, ' ', 0);
  568. for (i=n1; (step>=0 ? i<=n2 : i>=n2) && !CHECKBREAK(); i+=step) {
  569.     if (verbose) fprintf(stderr, "fornum: %d\n", i);
  570.     sprintf(buf,"%d",i);
  571.     set_var (LEVEL_SET, vname, buf);
  572.     exec_command(cstr);
  573.     }
  574. --H_stack;
  575. free (cstr);
  576. unset_var (LEVEL_SET, vname);
  577. return 0;
  578. }
  579.  
  580. /*
  581.  * foreach var_name  ( str str str str... str ) commands
  582.  * spacing is important (unfortunately)
  583.  *
  584.  * ac=0    1 2 3 4 5 6 7
  585.  * foreach i ( a b c ) echo $i
  586.  * foreach i ( *.c ) "echo -n "file ->";echo $i"
  587.  */
  588.  
  589. do_foreach()
  590. {
  591. register int cstart, cend;
  592. register char *cstr;
  593. char **fav;
  594. char vname[33];
  595. int i, verbose;
  596.  
  597. get_opt("v",&i);
  598. verbose=(options & 1);
  599. strcpy(vname, av[i++]);
  600. if (*av[i] == '(') i++;
  601. cstart = i;
  602. while (i<ac && *av[i] != ')') i++;
  603. if (i > ac) { fprintf(stderr,"')' expected\n"); return 20; }
  604. ++H_stack;
  605. cend = i;
  606.  
  607. fav = (char **)malloc(sizeof(char *) * (ac));
  608. cstr = compile_av (av, cend + 1, ac, ' ', 0);
  609.  
  610. for (i = cstart; i < cend; ++i) fav[i] = av[i];
  611.  
  612. for (i = cstart; i<cend && !CHECKBREAK(); ++i) {
  613.     set_var (LEVEL_SET, vname, fav[i]);
  614.     if (verbose) fprintf(stderr, "foreach: %s\n", fav[i]);
  615.     exec_command(cstr);
  616.     }
  617. --H_stack;
  618. free (fav);
  619. free (cstr);
  620. unset_var (LEVEL_SET, vname);
  621. return 0;
  622. }
  623.  
  624. do_forever(str)
  625. char *str;
  626. {
  627. int rcode = 0;
  628. char *ptr = next_word(str);
  629.  
  630. ++H_stack;
  631. for (;;) {
  632.     if (CHECKBREAK()) { rcode = 20; break; }
  633.     if (exec_command (ptr) < 0) {
  634.         str = get_var(LEVEL_SET, v_lasterr);
  635.         rcode = (str) ? atoi(str) : 20;
  636.         break;
  637.         }
  638.     }
  639. --H_stack;
  640. return rcode;
  641. }
  642.  
  643. do_exec(str)
  644. char *str;
  645. {
  646. return exec_command(next_word(str));
  647. }
  648.  
  649. extern struct Window *w;
  650. extern struct IntuitionBase *IntuitionBase;
  651.  
  652. do_window()
  653. {
  654. long x, y, maxwidth, maxheight, arg[5];
  655. unsigned int i;
  656. struct Screen *screen;
  657. struct Window *window;
  658.  
  659. get_opt("slfbaq", &i);
  660. if (options & 1)
  661.     SizeWindow(w, (long)(w->MinWidth-w->Width), (long)(w->MinHeight-w->Height));
  662. if (options & 2) {
  663.     x=-w->LeftEdge;
  664.     y=-w->TopEdge;
  665.     MoveWindow(w,x,y);
  666.     x=IntuitionBase->ActiveScreen->Width -w->Width;
  667.     y=IntuitionBase->ActiveScreen->Height-w->Height;
  668.     SizeWindow(w,x,y);
  669.     }
  670. if (options & 4) WindowToFront(w);
  671. if (options & 8) WindowToBack(w);
  672. if (options & 16) ActivateWindow(w);
  673. if(ac >= 5) {
  674.     for(i=1; i<5; i++) {
  675.         arg[i] = myatoi(av[i],0,1023); if (atoierr) return 20;
  676.         }
  677.     maxwidth = w->WScreen->Width;
  678.     maxheight= w->WScreen->Height;
  679.     if (arg[3] > maxwidth - arg[1] || arg[4] > maxheight- arg[2]) {
  680.         ierror(NULL, 500);
  681.         return 20;
  682.         }
  683.     x = -w->LeftEdge;
  684.     y = -w->TopEdge;
  685.     MoveWindow(w, x, y);
  686.     x = arg[3] - w->Width;
  687.     y = arg[4] - w->Height;
  688.     SizeWindow(w, x, y);
  689.     x = arg[1];
  690.     y = arg[2];
  691.     MoveWindow(w, x, y);
  692.     }
  693. if(options & 32) {
  694.     for (screen=IntuitionBase->FirstScreen; screen; screen=screen->NextScreen) {
  695.         printf("\nScreen \"%s\" (%d,%d,%dx%d):\n",
  696.             screen->Title,
  697.             screen->LeftEdge,
  698.             screen->TopEdge,
  699.             screen->Width,
  700.             screen->Height
  701.             );
  702.         for (window=screen->FirstWindow; window; window=window->NextWindow) {
  703.         printf("\tWindow\t\"%s\" (%d,%d,%dx%d)\n",
  704.             window->Title,
  705.             window->LeftEdge,
  706.             window->TopEdge,
  707.             window->Width,
  708.             window->Height
  709.             );
  710.         }
  711.         }
  712.     return 0;
  713.     }
  714. Delay(25L); /* pause 1/2 sec. before trying to print */
  715. printf("\014");
  716. return 0;
  717. }
  718.  
  719. setsystemtime(ds)
  720. struct DateStamp *ds;
  721. {
  722. struct timerequest tr;
  723. long secs= ds->ds_Days*86400 + ds->ds_Minute*60 + ds->ds_Tick/TICKS_PER_SECOND;
  724.  
  725. if (OpenDevice(TIMERNAME, UNIT_VBLANK, &tr, 0L)) {
  726.     fprintf(stderr,"Clock error: can't open timer device\n");
  727.     return;
  728.     }
  729. tr.tr_node.io_Message.mn_Node.ln_Type = NT_MESSAGE;
  730. tr.tr_node.io_Message.mn_Node.ln_Pri = 0L;
  731. tr.tr_node.io_Message.mn_Node.ln_Name = NULL;
  732. tr.tr_node.io_Message.mn_ReplyPort = NULL;
  733. tr.tr_node.io_Command = TR_SETSYSTIME;
  734. tr.tr_time.tv_secs = secs;
  735. tr.tr_time.tv_micro = 0L;
  736. if (DoIO (&tr)) fprintf(stderr,"Clock error: can't talk to timer device\n");
  737. CloseDevice (&tr);
  738. }
  739.  
  740. char tday[10];
  741.  
  742. char *dates(dss)
  743. struct DateStamp *dss;
  744. {
  745. static char timestr[40];
  746. char tdate[10], ttime[10];
  747. struct DateTime dt;
  748. struct DateStamp *myds=&(dt.dat_Stamp);
  749.  
  750. dt.dat_Format=FORMAT_DOS;
  751. dt.dat_StrDay=tday;
  752. dt.dat_StrDate=tdate;
  753. dt.dat_StrTime=ttime;
  754. dt.dat_Flags=NULL;
  755. myds->ds_Days=dss->ds_Days;
  756. myds->ds_Minute=dss->ds_Minute;
  757. myds->ds_Tick=dss->ds_Tick;
  758. StamptoStr(&dt);
  759. sprintf(timestr,"%s %s\n",tdate,ttime);
  760. timestr[18]='\n';
  761. timestr[19]='\0';    /* protection against bad timestamped files */
  762. return timestr;
  763. }
  764.  
  765. do_date()
  766. {
  767. struct DateStamp dss;
  768. register unsigned short i;
  769. struct DateTime dt;
  770.  
  771. dt.dat_Format=FORMAT_DOS;
  772. if (ac==1) {
  773.     DateStamp(&dss);
  774.     printf("%s %s",tday,dates(&dss));
  775.     }
  776. else {
  777.     DateStamp(& (dt.dat_Stamp));
  778.     for (i=1; i<ac; i++) {
  779.         dt.dat_StrDate=NULL;
  780.         dt.dat_StrTime=NULL;
  781.         dt.dat_Flags=DTF_FUTURE;
  782.         if (index(av[i],':')) dt.dat_StrTime=av[i];
  783.             else dt.dat_StrDate=av[i];
  784.         if (StrtoStamp(&dt)) ierror(av[i],500);
  785.         }
  786.     setsystemtime( & (dt.dat_Stamp) );
  787.     }
  788. return 0;
  789. }
  790.